babl: detect sRGB profiles from matrix

When TRCs also are matching, return internal sRGB instead of creating a
duplicate.

babl: indentation in trc

babl: move srgb detection to srgb_formula constructor

babl: fix overflow detection at end of luts

babl: implement interpolation for lut trcs

babl: icc implement ascii decoding of mluc

babl: add parametric handling for sRGB style TRCs (icc V4)

babl: use trcs own fun directly in early stages

tools: babl-icc-rewrite; abort with error message instead of segfault

babl: use babl_malloc instead of misgided use of aligned_alloc thinking it was like alloca

babl: use _aligned_malloc() instead of aligned_alloc() on Win32.

Thanks to Lionel N. for raising the issue. It was failing to build for
Windows with:
> babl/babl-space.c:503: undefined reference to `aligned_alloc'
Windows has apparently a similar API, except that the size and alignment
parameters are inverted.
See https://msdn.microsoft.com/library/8z34s9c6.aspx

babl-icc: add support for some ICCv4 profiles

RGB Matrix profiles with not too complex (or sRGB) parametric TRCs is what
should work fine.

babl: move RGB space conversion code to babl-space.c

babl: make trcs capable of iterating buffers

babl: do one SSE2 memory load per pixel for color matrix transform

babl: add sse2 acceleration for color transform

Many of the code paths are now duplicated, the duplication should decrease as
the SSE2/SIMD versions evolve further and stop resembling the code they were
cloned from.

babl: change MAX_BUFFER_SIZE to 512

This is the value that determins the smaller size big buffers are broken up in
and processed chunk-by chunk for multi-path conversions.

With tools/babl-benchmark for a particular workload and machine the following
results were attained, all values are in mb/s. There seem to be two sweet-spots
one around 128 and one around 512. Now using 512 which probably has better
cache behavior on most cpus than the old value 2048.

MAX_BUFFER_SIZE benchmarks,
    8:  437.1
   16:  458.8
   32:  495.0
   64:  482.6
   96:  496.4
  127:  508.8
  128:  514.2 506.7 495.1
  130:  494.6
  150:  479.5
  255:  492.2
  256:  491.0 486.8
  384:  500.8
  450:  503.7
  500:  499.6 496.5
  511:  477.8
  512:  511.0 508.7 500.6
  514:  499.3
  515:  504.7 502
  520:  512.9 491
  530:  501.8
  550:  483.3
  768:  493.0
 1024:  491.6
 2048:  489.5
 4096:  501.2
 8192:  499.0

babl: refactor matrix_mul_vector further towards SIMD

babl: register more RGB auto-converters for non-sRGB spaces

babl: use floating point version of srgb trc func

tools: add c program for validating TRC approximations

replace gamma approximations

babl: move trc functions inside babl-trc.c

Use lolremez 9 degree polynominal approximations for 1.8 and 2.2 gamma.

babl: add separate functions for 1.8 and 2.2 gamma

babl: optimize powf and its use in u8tou8 internal converter

babl: change how conversion computers (own) error

tools: babl-benchmark, print chosen paths

babl: include out own powf implementation

reduce set of default RGB spaces

extensions/gray: add const for rgbtoxyz matrix return

babl: only care about single precision for TRC

babl: make use of more direct trc dispatch in base

extensions: more direct trc dispatch

babl: speed up trc dispatch

By splitting the core computation done by the TRC down to callbacks of
different types, that all optionally can use the provided trc object.  This way
we can move the conditional for the polymorphism out of loops. The higher level
API of using the TRC still works - and is also accelerated by this change.

babl: silence cast warning

babl: add commented out u8 rgb to rgb converter

babl: register conversions between all RGB spaces

we register RGBA float and R'G'B'A float converters
between all spaces. This permits the converters between
precisions for each space to take effect.

babl: add single precision cmm matrices

babl: on demand clone sRGB conversions

When a new RGB space is encountered clone all sRGB space to sRGB space
conversions, under the assumption that they are implemented respecting/using
the customizable TRCs of babl.

extensions/CIE: use RGB space functions for xyz

extensions/gimp-8bit: use RGB space TRCs

extensions/float: use RGB space TRCs

extensions/cairo: use RGB space trc functions

babl/babl-format: add formats with custom RGB spaces to format db

tools/babl-benchmark: exclude conversions to self from average

The fast path the checks for source == dst, and replace with memcpy works,
including these memcpy aliases makes the barchart harder to read and the
average further from the median.

babl: move matrix code to new file babl-matrix.h

babl: remove unused babl_space_get_chromaticities

babl: make cache loading/parsing valgrind clean

babl: initialize used BablModel struct member data on init

babl: iterate on public space/icc API

babl-icc: length of string in descr should include \0

tools: Use rand when random is unavailable

borrowed from c1f075f22c70de54c2b04ca5df008a5e406d3ca9

babl-icc: detect 2.2 and 1.8 gammas LUTs

babl-icc: implement LUT TRC place holder code

babl-icc: detect sRGB LUT TRC and use babl's native sRGB TRC

Also add serialization of sRGB as an on-the fly generated 1024 element LUT.

babl-icc: implement reading and writing of LUTs for TRC

babl-icc: create struct for abstracting ICC file access

This also makes the ICC parsing re-entrant by getting rid of global variables.

tools: add a tool for testing icc profile writing

babl-icc: change priority of way to get matrix

babl: add icc generator

Add API to generate concise ICC profiles in memory from babl-spaces, seems
complete apart for tRCs.

babl: add babl-trc.h to Makefile.am

babl: remove lingering reference to rgb-constants.h in makefile

tools: add -e option to babl-icc-dumper, that shows exact fixed point values

babl: use typedefs and structs for fixed point numbers

also adds code to print exact decimal representations of numbers found in icc
files, can be useful for tuning constants fed in - our observing differences,
it turns out that ~6digits of precision is enough for double float and fixed point 32bit to differ in values in icc profiles.

tools: add babl-icc-dump

This commandline tool contains code to parse the v4 elements babl-icc currently
doesn't make use of. It loads data from the ICC profile directly into double
precision floats.

  CIE xy red: 0.640009 0.330022
  CIE xy green: 0.300008 0.600015
  CIE xy blue: 0.150011 0.059998

Is due to IEEE double precision floats not being as precise as the fixed point
values in the profile, which are *exactly*:

  CIE xy red:   0.6400  0.3300
  CIE xy green: 0.3000  0.6000
  CIE xy blue:  0.1500  0.0600

babl: shorten missing fish message to mostly fit 80col

tools/babl-benchmark: add unicode barchart to results

babl: icc parser, fix misname s15f16

tools: add a throughput benchmark

babl: adapt conversion searcher for remodels

babl: proof icc parsing against corrupt data

babl: add babl_space_rgb_icc

docs: remove draft roadmap for custom primaries

babl: add babl_space_rgb_matrix

babl: add handling of BABL_RGB_OVERRIDE environment variable

babl: return the linear TRC when 1.0 is asked for numerically

babl: get rid of RGB_LUMINANCE constants

s/babl_space_new/babl_space_rgb_chromaticities

babl: respond to gcc warnings

babl: make some of the new space API internal for now

add BablTRC class, that handles gamma or sRGB

Done this way, it is easily extendable to also handle LUTs.

extensions/CIE: replace rgb-to-xyz with one from source space

tests: add a test verifying that buffers are converted between RGB spaces

make use of babl space for reference computations

add BablSpace for specifying chromaticities/TRC

babl: util.h fix double include guard

Add the BablConversion as first argument of all conversions

This is neccesary to be able to access state of source/destination from within
registered conversions.

post-release version bump

release 0.1.30

babl: clean up various syntax bugs.

Trailing whitespaces, tabs, etc.

configure: do not link with pthread on Android.

It turns out Bionic (Android C library) has its own implementation of
pthread. With this minor change, babl is fully cross-compilable for
Android.

palette: make the conversion hash table volatile

... to avoid the theoretical possiblity of hash table entires being
read more than once during conversion, defying atomicity.  Very,
*very* paranoid, but what the hell :P

palette: make palette conversion thread safe

Conversion from RGBA u8 to an 8-bit palette format caches conversion
results in a hash table, belonging to the palette model.  Currently,
manipulation of the hash table is not thread safe -- when multiple
threads convert to the same palette format concurrently, the result
may be wrong.  In particular, there is a race condition when two
different colors that share the same hash are converted concurrently.

Fix this by changing the hash table layout, so that it can be
modified atomically.  We assume that aligned 32-bit writes are
atomic.

Note that the new layout is only suitable for palettes with up to
256 colors, but this is all we use the hash table for ATM anyway.

Add a regression test.

extensions: just some minor cleaning of trailing whitespaces.

babl-internal: tidy up some log messages

bug #783704, Check db NULL to avoid segfault if babl not initiated,

tests: fix typo in hsva.c

"rgba to hsva" -> "hsva to rgba"; got swapped by commit
c8b5eee3f86a49bd093929f0bd16ef780de88c67.  Thanks to Edward_E for
catching that.

Bug 780016 - Conversion path between nonpremultiplied formats ...

.. may pass through a premultiplied format, losing color information
of fully transparent pixels

Add a few pixels with zero alpha to the test pixels array, to penalize
such paths.  16 pixels seem to be enough for the conversions tested,
using the default tolerance.

Add a regression test.

babl-gen-test-pixels: update floating-point format of output ...

... to match commit 37947d19cd217ef5a04da46627a60ccde8925122.

tests: add CHECK_CONV_FLOAT to common.inc

Like CHECK_CONV, but for floating point destination types.

Use CHECK_CONV_FLOAT in hsva.c and hsl.c, instead of custom
CHECK_CONV implementations.  To be used by another test soon.